<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE CPP #-}</span><span class="hs-cpp">
#if __GLASGOW_HASKELL__ &gt;= 702
</span><span class="hs-pragma">{-# LANGUAGE Safe #-}</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#if __GLASGOW_HASKELL__ &gt;= 706
</span><span class="hs-pragma">{-# LANGUAGE PolyKinds #-}</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#if __GLASGOW_HASKELL__ &gt;= 710
</span><span class="hs-pragma">{-# LANGUAGE AutoDeriveTypeable #-}</span><span class="hs-cpp">
#endif
</span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-13"></span><span class="hs-comment">-- Module      :  Data.Functor.Constant</span><span>
</span><span id="line-14"></span><span class="hs-comment">-- Copyright   :  (c) Ross Paterson 2010</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- License     :  BSD-style (see the file LICENSE)</span><span>
</span><span id="line-16"></span><span class="hs-comment">--</span><span>
</span><span id="line-17"></span><span class="hs-comment">-- Maintainer  :  R.Paterson@city.ac.uk</span><span>
</span><span id="line-18"></span><span class="hs-comment">-- Stability   :  experimental</span><span>
</span><span id="line-19"></span><span class="hs-comment">-- Portability :  portable</span><span>
</span><span id="line-20"></span><span class="hs-comment">--</span><span>
</span><span id="line-21"></span><span class="hs-comment">-- The constant functor.</span><span>
</span><span id="line-22"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-23"></span><span>
</span><span id="line-24"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Data.Functor.Constant</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-25"></span><span>    </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier">Constant</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-26"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-27"></span><span>
</span><span id="line-28"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#"><span class="hs-identifier">Data.Functor.Classes</span></a></span><span class="hs-cpp">
#if MIN_VERSION_base(4,12,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Contravariant.html#"><span class="hs-identifier">Data.Functor.Contravariant</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-33"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Applicative.html#"><span class="hs-identifier">Control.Applicative</span></a></span><span>
</span><span id="line-34"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Foldable.html#"><span class="hs-identifier">Data.Foldable</span></a></span><span>
</span><span id="line-35"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Monoid.html#"><span class="hs-identifier">Data.Monoid</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier">Monoid</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-36"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Traversable.html#"><span class="hs-identifier">Data.Traversable</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Traversable.html#Traversable"><span class="hs-identifier">Traversable</span></a></span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier">traverse</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#if MIN_VERSION_base(4,8,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Bifunctor.html#"><span class="hs-identifier">Data.Bifunctor</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Bifunctor.html#Bifunctor"><span class="hs-identifier">Bifunctor</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#if MIN_VERSION_base(4,9,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Semigroup.html#"><span class="hs-identifier">Data.Semigroup</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#Semigroup"><span class="hs-identifier">Semigroup</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#if MIN_VERSION_base(4,10,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Bifoldable.html#"><span class="hs-identifier">Data.Bifoldable</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Bifoldable.html#Bifoldable"><span class="hs-identifier">Bifoldable</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-45"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Bitraversable.html#"><span class="hs-identifier">Data.Bitraversable</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Bitraversable.html#Bitraversable"><span class="hs-identifier">Bitraversable</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span> </span><span class="hs-keyword">hiding</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Foldable.html#null"><span class="hs-identifier">null</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier">length</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-48"></span><span>
</span><span id="line-49"></span><span class="hs-comment">-- | Constant functor.</span><span>
</span><span id="line-50"></span><span class="hs-keyword">newtype</span><span> </span><span id="Constant"><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span></span><span> </span><span id="local-6989586621679085656"><span class="annot"><a href="#local-6989586621679085656"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span id="local-6989586621679085655"><span class="annot"><a href="#local-6989586621679085655"><span class="hs-identifier hs-type">b</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="Constant"><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span></span><span> </span><span class="hs-special">{</span><span> </span><span id="getConstant"><span class="annot"><span class="annottext">forall {k} a (b :: k). Constant a b -&gt; a
</span><a href="Data.Functor.Constant.html#getConstant"><span class="hs-identifier hs-var hs-var">getConstant</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679085656"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-51"></span><span>    </span><span class="hs-keyword">deriving</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679085335"><span id="local-6989586621679085339"><span class="annot"><span class="annottext">Constant a b -&gt; Constant a b -&gt; Bool
(Constant a b -&gt; Constant a b -&gt; Bool)
-&gt; (Constant a b -&gt; Constant a b -&gt; Bool) -&gt; Eq (Constant a b)
forall a. (a -&gt; a -&gt; Bool) -&gt; (a -&gt; a -&gt; Bool) -&gt; Eq a
forall a k (b :: k). Eq a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
/= :: Constant a b -&gt; Constant a b -&gt; Bool
$c/= :: forall a k (b :: k). Eq a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
== :: Constant a b -&gt; Constant a b -&gt; Bool
$c== :: forall a k (b :: k). Eq a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
</span><span class="hs-identifier hs-var hs-var hs-var hs-var hs-var hs-var">Eq</span></span></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679085301"><span id="local-6989586621679085305"><span id="local-6989586621679085309"><span id="local-6989586621679085313"><span id="local-6989586621679085317"><span id="local-6989586621679085321"><span id="local-6989586621679085325"><span class="annot"><span class="annottext">Eq (Constant a b)
Eq (Constant a b)
-&gt; (Constant a b -&gt; Constant a b -&gt; Ordering)
-&gt; (Constant a b -&gt; Constant a b -&gt; Bool)
-&gt; (Constant a b -&gt; Constant a b -&gt; Bool)
-&gt; (Constant a b -&gt; Constant a b -&gt; Bool)
-&gt; (Constant a b -&gt; Constant a b -&gt; Bool)
-&gt; (Constant a b -&gt; Constant a b -&gt; Constant a b)
-&gt; (Constant a b -&gt; Constant a b -&gt; Constant a b)
-&gt; Ord (Constant a b)
Constant a b -&gt; Constant a b -&gt; Bool
Constant a b -&gt; Constant a b -&gt; Ordering
Constant a b -&gt; Constant a b -&gt; Constant a b
forall a.
Eq a
-&gt; (a -&gt; a -&gt; Ordering)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; a)
-&gt; (a -&gt; a -&gt; a)
-&gt; Ord a
forall {a} {k} {b :: k}. Ord a =&gt; Eq (Constant a b)
forall a k (b :: k). Ord a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
forall a k (b :: k).
Ord a =&gt;
Constant a b -&gt; Constant a b -&gt; Ordering
forall a k (b :: k).
Ord a =&gt;
Constant a b -&gt; Constant a b -&gt; Constant a b
min :: Constant a b -&gt; Constant a b -&gt; Constant a b
$cmin :: forall a k (b :: k).
Ord a =&gt;
Constant a b -&gt; Constant a b -&gt; Constant a b
max :: Constant a b -&gt; Constant a b -&gt; Constant a b
$cmax :: forall a k (b :: k).
Ord a =&gt;
Constant a b -&gt; Constant a b -&gt; Constant a b
&gt;= :: Constant a b -&gt; Constant a b -&gt; Bool
$c&gt;= :: forall a k (b :: k). Ord a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
&gt; :: Constant a b -&gt; Constant a b -&gt; Bool
$c&gt; :: forall a k (b :: k). Ord a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
&lt;= :: Constant a b -&gt; Constant a b -&gt; Bool
$c&lt;= :: forall a k (b :: k). Ord a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
&lt; :: Constant a b -&gt; Constant a b -&gt; Bool
$c&lt; :: forall a k (b :: k). Ord a =&gt; Constant a b -&gt; Constant a b -&gt; Bool
compare :: Constant a b -&gt; Constant a b -&gt; Ordering
$ccompare :: forall a k (b :: k).
Ord a =&gt;
Constant a b -&gt; Constant a b -&gt; Ordering
</span><span class="hs-identifier hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var">Ord</span></span></span></span></span></span></span></span></span><span class="hs-special">)</span><span>
</span><span id="line-52"></span><span>
</span><span id="line-53"></span><span class="hs-comment">-- These instances would be equivalent to the derived instances of the</span><span>
</span><span id="line-54"></span><span class="hs-comment">-- newtype if the field were removed.</span><span>
</span><span id="line-55"></span><span>
</span><span id="line-56"></span><span id="local-6989586621679085638"><span id="local-6989586621679085639"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085289"><span id="local-6989586621679085291"><span id="local-6989586621679085293"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085639"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085639"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085638"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-57"></span><span>    </span><span id="local-6989586621679085286"><span class="annot"><span class="annottext">readsPrec :: Int -&gt; ReadS (Constant a b)
</span><a href="../../base/src/GHC.Read.html#readsPrec"><span class="hs-identifier hs-var hs-var hs-var hs-var">readsPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(String -&gt; ReadS (Constant a b)) -&gt; Int -&gt; ReadS (Constant a b)
forall a. (String -&gt; ReadS a) -&gt; Int -&gt; ReadS a
</span><a href="../../base/src/Data.Functor.Classes.html#readsData"><span class="hs-identifier hs-var">readsData</span></a></span><span> </span><span class="annot"><span class="annottext">((String -&gt; ReadS (Constant a b)) -&gt; Int -&gt; ReadS (Constant a b))
-&gt; (String -&gt; ReadS (Constant a b)) -&gt; Int -&gt; ReadS (Constant a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-58"></span><span>         </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; String -&gt; (a -&gt; Constant a b) -&gt; String -&gt; ReadS (Constant a b)
forall a t.
(Int -&gt; ReadS a) -&gt; String -&gt; (a -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="../../base/src/Data.Functor.Classes.html#readsUnaryWith"><span class="hs-identifier hs-var">readsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="../../base/src/GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Constant&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a b
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span></span></span><span>
</span><span id="line-59"></span><span>
</span><span id="line-60"></span><span id="local-6989586621679085627"><span id="local-6989586621679085628"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085278"><span id="local-6989586621679085280"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085628"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085628"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085627"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-61"></span><span>    </span><span id="local-6989586621679085275"><span class="annot"><span class="annottext">showsPrec :: Int -&gt; Constant a b -&gt; ShowS
</span><a href="../../base/src/GHC.Show.html#showsPrec"><span class="hs-identifier hs-var hs-var hs-var hs-var">showsPrec</span></a></span></span><span> </span><span id="local-6989586621679085273"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679085273"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085272"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085272"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="../../base/src/Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="../../base/src/GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Constant&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679085273"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085272"><span class="hs-identifier hs-var">x</span></a></span></span></span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span class="hs-comment">-- Instances of lifted Prelude classes</span><span>
</span><span id="line-64"></span><span>
</span><span id="line-65"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Eq2"><span class="hs-identifier hs-type">Eq2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-66"></span><span>    </span><span id="local-6989586621679085267"><span class="annot"><span class="annottext">liftEq2 :: forall a b c d.
(a -&gt; b -&gt; Bool)
-&gt; (c -&gt; d -&gt; Bool) -&gt; Constant a c -&gt; Constant b d -&gt; Bool
</span><a href="../../base/src/Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq2</span></a></span></span><span> </span><span id="local-6989586621679085265"><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679085265"><span class="hs-identifier hs-var">eq</span></a></span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Bool
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085264"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085264"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085263"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679085263"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Bool
</span><a href="#local-6989586621679085265"><span class="hs-identifier hs-var">eq</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085264"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679085263"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-67"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#liftEq2"><span class="hs-pragma hs-type">liftEq2</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-68"></span><span>
</span><span id="line-69"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Ord2"><span class="hs-identifier hs-type">Ord2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-70"></span><span>    </span><span id="local-6989586621679085257"><span class="annot"><span class="annottext">liftCompare2 :: forall a b c d.
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; Constant a c -&gt; Constant b d -&gt; Ordering
</span><a href="../../base/src/Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare2</span></a></span></span><span> </span><span id="local-6989586621679085255"><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679085255"><span class="hs-identifier hs-var">comp</span></a></span></span><span> </span><span class="annot"><span class="annottext">c -&gt; d -&gt; Ordering
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085254"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085254"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085253"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679085253"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Ordering
</span><a href="#local-6989586621679085255"><span class="hs-identifier hs-var">comp</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085254"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679085253"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-71"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#liftCompare2"><span class="hs-pragma hs-type">liftCompare2</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-72"></span><span>
</span><span id="line-73"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085246"><span id="local-6989586621679085248"><span id="local-6989586621679085250"><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Read2"><span class="hs-identifier hs-type">Read2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-74"></span><span>    </span><span id="local-6989586621679085244"><span class="annot"><span class="annottext">liftReadsPrec2 :: forall a b.
(Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; (Int -&gt; ReadS b)
-&gt; ReadS [b]
-&gt; Int
-&gt; ReadS (Constant a b)
</span><a href="../../base/src/Data.Functor.Classes.html#liftReadsPrec2"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadsPrec2</span></a></span></span><span> </span><span id="local-6989586621679085242"><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679085242"><span class="hs-identifier hs-var">rp</span></a></span></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS b
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">ReadS [b]
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(String -&gt; ReadS (Constant a b)) -&gt; Int -&gt; ReadS (Constant a b)
forall a. (String -&gt; ReadS a) -&gt; Int -&gt; ReadS a
</span><a href="../../base/src/Data.Functor.Classes.html#readsData"><span class="hs-identifier hs-var">readsData</span></a></span><span> </span><span class="annot"><span class="annottext">((String -&gt; ReadS (Constant a b)) -&gt; Int -&gt; ReadS (Constant a b))
-&gt; (String -&gt; ReadS (Constant a b)) -&gt; Int -&gt; ReadS (Constant a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-75"></span><span>         </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; String -&gt; (a -&gt; Constant a b) -&gt; String -&gt; ReadS (Constant a b)
forall a t.
(Int -&gt; ReadS a) -&gt; String -&gt; (a -&gt; t) -&gt; String -&gt; ReadS t
</span><a href="../../base/src/Data.Functor.Classes.html#readsUnaryWith"><span class="hs-identifier hs-var">readsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
</span><a href="#local-6989586621679085242"><span class="hs-identifier hs-var">rp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Constant&quot;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a b
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span>
</span><span id="line-76"></span><span>
</span><span id="line-77"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085239"><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Show2"><span class="hs-identifier hs-type">Show2</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-78"></span><span>    </span><span id="local-6989586621679085237"><span class="annot"><span class="annottext">liftShowsPrec2 :: forall a b.
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; Constant a b
-&gt; ShowS
</span><a href="../../base/src/Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec2</span></a></span></span><span> </span><span id="local-6989586621679085235"><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679085235"><span class="hs-identifier hs-var">sp</span></a></span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; b -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">[b] -&gt; ShowS
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621679085234"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679085234"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085233"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085233"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
forall a. (Int -&gt; a -&gt; ShowS) -&gt; String -&gt; Int -&gt; a -&gt; ShowS
</span><a href="../../base/src/Data.Functor.Classes.html#showsUnaryWith"><span class="hs-identifier hs-var">showsUnaryWith</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
</span><a href="#local-6989586621679085235"><span class="hs-identifier hs-var">sp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Constant&quot;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679085234"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085233"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-79"></span><span>
</span><span id="line-80"></span><span id="local-6989586621679085582"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Eq</span></span><span> </span><span class="annot"><a href="#local-6989586621679085582"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Eq1"><span class="hs-identifier hs-type">Eq1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085582"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-81"></span><span>    </span><span id="local-6989586621679085226"><span class="annot"><span class="annottext">liftEq :: forall a b.
(a -&gt; b -&gt; Bool) -&gt; Constant a a -&gt; Constant a b -&gt; Bool
</span><a href="../../base/src/Data.Functor.Classes.html#liftEq"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftEq</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Bool)
-&gt; (a -&gt; b -&gt; Bool) -&gt; Constant a a -&gt; Constant a b -&gt; Bool
forall (f :: * -&gt; * -&gt; *) a b c d.
Eq2 f =&gt;
(a -&gt; b -&gt; Bool) -&gt; (c -&gt; d -&gt; Bool) -&gt; f a c -&gt; f b d -&gt; Bool
</span><a href="../../base/src/Data.Functor.Classes.html#liftEq2"><span class="hs-identifier hs-var">liftEq2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">(==)</span></span><span>
</span><span id="line-82"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#liftEq"><span class="hs-pragma hs-type">liftEq</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-83"></span><span id="local-6989586621679085574"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Ord</span></span><span> </span><span class="annot"><a href="#local-6989586621679085574"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Ord1"><span class="hs-identifier hs-type">Ord1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085574"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-84"></span><span>    </span><span id="local-6989586621679085215"><span class="annot"><span class="annottext">liftCompare :: forall a b.
(a -&gt; b -&gt; Ordering) -&gt; Constant a a -&gt; Constant a b -&gt; Ordering
</span><a href="../../base/src/Data.Functor.Classes.html#liftCompare"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftCompare</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Ordering)
-&gt; (a -&gt; b -&gt; Ordering) -&gt; Constant a a -&gt; Constant a b -&gt; Ordering
forall (f :: * -&gt; * -&gt; *) a b c d.
Ord2 f =&gt;
(a -&gt; b -&gt; Ordering)
-&gt; (c -&gt; d -&gt; Ordering) -&gt; f a c -&gt; f b d -&gt; Ordering
</span><a href="../../base/src/Data.Functor.Classes.html#liftCompare2"><span class="hs-identifier hs-var">liftCompare2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><span class="hs-identifier hs-var">compare</span></span><span>
</span><span id="line-85"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#liftCompare"><span class="hs-pragma hs-type">liftCompare</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-86"></span><span id="local-6989586621679085566"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085206"><span id="local-6989586621679085208"><span id="local-6989586621679085210"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085566"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Read1"><span class="hs-identifier hs-type">Read1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085566"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-87"></span><span>    </span><span id="local-6989586621679085201"><span class="annot"><span class="annottext">liftReadsPrec :: forall a.
(Int -&gt; ReadS a) -&gt; ReadS [a] -&gt; Int -&gt; ReadS (Constant a a)
</span><a href="../../base/src/Data.Functor.Classes.html#liftReadsPrec"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftReadsPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; (Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; Int
-&gt; ReadS (Constant a a)
forall (f :: * -&gt; * -&gt; *) a b.
Read2 f =&gt;
(Int -&gt; ReadS a)
-&gt; ReadS [a]
-&gt; (Int -&gt; ReadS b)
-&gt; ReadS [b]
-&gt; Int
-&gt; ReadS (f a b)
</span><a href="../../base/src/Data.Functor.Classes.html#liftReadsPrec2"><span class="hs-identifier hs-var">liftReadsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="../../base/src/GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS [a]
forall a. Read a =&gt; ReadS [a]
</span><a href="../../base/src/GHC.Read.html#readList"><span class="hs-identifier hs-var">readList</span></a></span><span>
</span><span id="line-88"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#liftReadsPrec"><span class="hs-pragma hs-type">liftReadsPrec</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-89"></span><span id="local-6989586621679085561"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085196"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085561"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#Show1"><span class="hs-identifier hs-type">Show1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085561"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-90"></span><span>    </span><span id="local-6989586621679085191"><span class="annot"><span class="annottext">liftShowsPrec :: forall a.
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS) -&gt; Int -&gt; Constant a a -&gt; ShowS
</span><a href="../../base/src/Data.Functor.Classes.html#liftShowsPrec"><span class="hs-identifier hs-var hs-var hs-var hs-var">liftShowsPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; Int
-&gt; Constant a a
-&gt; ShowS
forall (f :: * -&gt; * -&gt; *) a b.
Show2 f =&gt;
(Int -&gt; a -&gt; ShowS)
-&gt; ([a] -&gt; ShowS)
-&gt; (Int -&gt; b -&gt; ShowS)
-&gt; ([b] -&gt; ShowS)
-&gt; Int
-&gt; f a b
-&gt; ShowS
</span><a href="../../base/src/Data.Functor.Classes.html#liftShowsPrec2"><span class="hs-identifier hs-var">liftShowsPrec2</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; ShowS
forall a. Show a =&gt; Int -&gt; a -&gt; ShowS
</span><a href="../../base/src/GHC.Show.html#showsPrec"><span class="hs-identifier hs-var">showsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ShowS
forall a. Show a =&gt; [a] -&gt; ShowS
</span><a href="../../base/src/GHC.Show.html#showList"><span class="hs-identifier hs-var">showList</span></a></span><span>
</span><span id="line-91"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Classes.html#liftShowsPrec"><span class="hs-pragma hs-type">liftShowsPrec</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-92"></span><span>
</span><span id="line-93"></span><span id="local-6989586621679085554"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085186"><span class="annot"><a href="../../base/src/GHC.Base.html#Functor"><span class="hs-identifier hs-type">Functor</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085554"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-94"></span><span>    </span><span id="local-6989586621679085184"><span class="annot"><span class="annottext">fmap :: forall a b. (a -&gt; b) -&gt; Constant a a -&gt; Constant a b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var hs-var hs-var hs-var">fmap</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; b
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085183"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085183"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a b
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085183"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-95"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-pragma hs-type">fmap</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-96"></span><span>
</span><span id="line-97"></span><span id="local-6989586621679085536"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085152"><span id="local-6989586621679085154"><span id="local-6989586621679085156"><span id="local-6989586621679085158"><span id="local-6989586621679085160"><span id="local-6989586621679085164"><span id="local-6989586621679085166"><span id="local-6989586621679085168"><span id="local-6989586621679085170"><span id="local-6989586621679085172"><span id="local-6989586621679085174"><span id="local-6989586621679085176"><span id="local-6989586621679085178"><span id="local-6989586621679085181"><span class="annot"><a href="../../base/src/Data.Foldable.html#Foldable"><span class="hs-identifier hs-type">Foldable</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085536"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span></span></span></span></span></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-98"></span><span>    </span><span id="local-6989586621679085148"><span class="annot"><span class="annottext">foldMap :: forall m a. Monoid m =&gt; (a -&gt; m) -&gt; Constant a a -&gt; m
</span><a href="../../base/src/Data.Foldable.html#foldMap"><span class="hs-identifier hs-var hs-var hs-var hs-var">foldMap</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; m
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span>
</span><span id="line-99"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Foldable.html#foldMap"><span class="hs-pragma hs-type">foldMap</span></a></span><span> </span><span class="hs-pragma">#-}</span><span class="hs-cpp">
#if MIN_VERSION_base(4,8,0)
</span><span>    </span><span id="local-6989586621679085146"><span class="annot"><span class="annottext">null :: forall a. Constant a a -&gt; Bool
</span><a href="#local-6989586621679085146"><span class="hs-identifier hs-var hs-var hs-var hs-var">null</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-102"></span><span>    </span><span id="local-6989586621679085145"><span class="annot"><span class="annottext">length :: forall a. Constant a a -&gt; Int
</span><a href="#local-6989586621679085145"><span class="hs-identifier hs-var hs-var hs-var hs-var">length</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-105"></span><span id="local-6989586621679085519"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085134"><span id="local-6989586621679085136"><span id="local-6989586621679085138"><span class="annot"><a href="../../base/src/Data.Traversable.html#Traversable"><span class="hs-identifier hs-type">Traversable</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085519"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-106"></span><span>    </span><span id="local-6989586621679085130"><span class="annot"><span class="annottext">traverse :: forall (f :: * -&gt; *) a b.
Applicative f =&gt;
(a -&gt; f b) -&gt; Constant a a -&gt; f (Constant a b)
</span><a href="#local-6989586621679085130"><span class="hs-identifier hs-var hs-var hs-var hs-var">traverse</span></a></span></span><span> </span><span class="annot"><span class="annottext">a -&gt; f b
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085129"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085129"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Constant a b -&gt; f (Constant a b)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Constant a b
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085129"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-107"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-pragma hs-type">traverse</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span class="hs-cpp">

#if MIN_VERSION_base(4,9,0)
</span><span id="local-6989586621679085508"><span id="local-6989586621679085509"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085124"><span id="local-6989586621679085126"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#Semigroup"><span class="hs-identifier hs-type">Semigroup</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085509"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Semigroup"><span class="hs-identifier hs-type">Semigroup</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085509"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085508"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-111"></span><span>    </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085121"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085121"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679085120"><span class="annot"><span class="annottext">&lt;&gt; :: Constant a b -&gt; Constant a b -&gt; Constant a b
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;&gt;</span></a></span></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085119"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085119"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a b
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085121"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085119"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-112"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span></span></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-115"></span><span id="local-6989586621679085498"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085109"><span id="local-6989586621679085111"><span id="local-6989586621679085113"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085498"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Applicative"><span class="hs-identifier hs-type">Applicative</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085498"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-116"></span><span>    </span><span id="local-6989586621679085106"><span class="annot"><span class="annottext">pure :: forall a. a -&gt; Constant a a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var hs-var hs-var hs-var">pure</span></a></span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a a
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span>
</span><span id="line-117"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#pure"><span class="hs-pragma hs-type">pure</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-118"></span><span>    </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085104"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085104"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679085103"><span class="annot"><span class="annottext">&lt;*&gt; :: forall a b. Constant a (a -&gt; b) -&gt; Constant a a -&gt; Constant a b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;*&gt;</span></a></span></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085102"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085102"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a b
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085104"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Monoid a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#mappend"><span class="hs-operator hs-var">`mappend`</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085102"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-119"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;*&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-120"></span><span>
</span><span id="line-121"></span><span id="local-6989586621679085492"><span id="local-6989586621679085493"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085095"><span id="local-6989586621679085097"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085493"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085493"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085492"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-122"></span><span>    </span><span id="local-6989586621679085092"><span class="annot"><span class="annottext">mempty :: Constant a b
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var hs-var hs-var hs-var">mempty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a b
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span>
</span><span id="line-123"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-pragma hs-type">mempty</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span class="hs-cpp">
#if !MIN_VERSION_base(4,11,0)
</span><span>    </span><span class="hs-comment">-- From base-4.11, Monoid(mappend) defaults to Semigroup((&lt;&gt;))</span><span>
</span><span id="line-126"></span><span>    </span><span class="hs-identifier">Constant</span><span> </span><span class="hs-identifier">x</span><span> </span><span class="hs-special">`</span><span class="hs-identifier">mappend</span><span class="hs-special">`</span><span> </span><span class="hs-identifier">Constant</span><span> </span><span class="hs-identifier">y</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">Constant</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">x</span><span> </span><span class="hs-special">`</span><span class="hs-identifier">mappend</span><span class="hs-special">`</span><span> </span><span class="hs-identifier">y</span><span class="hs-special">)</span><span>
</span><span id="line-127"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">mappend</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">
#if MIN_VERSION_base(4,8,0)
</span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085090"><span class="annot"><a href="../../base/src/Data.Bifunctor.html#Bifunctor"><span class="hs-identifier hs-type">Bifunctor</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-132"></span><span>    </span><span id="local-6989586621679085086"><span class="annot"><span class="annottext">first :: forall a b c. (a -&gt; b) -&gt; Constant a c -&gt; Constant b c
</span><a href="../../base/src/Data.Bifunctor.html#first"><span class="hs-identifier hs-var hs-var hs-var hs-var">first</span></a></span></span><span> </span><span id="local-6989586621679085084"><span class="annot"><span class="annottext">a -&gt; b
</span><a href="#local-6989586621679085084"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085083"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085083"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">b -&gt; Constant b c
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; b
</span><a href="#local-6989586621679085084"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085083"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-133"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Bifunctor.html#first"><span class="hs-pragma hs-type">first</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-134"></span><span>    </span><span id="local-6989586621679085082"><span class="annot"><span class="annottext">second :: forall b c a. (b -&gt; c) -&gt; Constant a b -&gt; Constant a c
</span><a href="../../base/src/Data.Bifunctor.html#second"><span class="hs-identifier hs-var hs-var hs-var hs-var">second</span></a></span></span><span> </span><span class="annot"><span class="annottext">b -&gt; c
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085080"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085080"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a c
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085080"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-135"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Bifunctor.html#second"><span class="hs-pragma hs-type">second</span></a></span><span> </span><span class="hs-pragma">#-}</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">
#if MIN_VERSION_base(4,10,0)
</span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085073"><span id="local-6989586621679085075"><span id="local-6989586621679085078"><span class="annot"><a href="../../base/src/Data.Bifoldable.html#Bifoldable"><span class="hs-identifier hs-type">Bifoldable</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-140"></span><span>    </span><span id="local-6989586621679085070"><span class="annot"><span class="annottext">bifoldMap :: forall m a b. Monoid m =&gt; (a -&gt; m) -&gt; (b -&gt; m) -&gt; Constant a b -&gt; m
</span><a href="../../base/src/Data.Bifoldable.html#bifoldMap"><span class="hs-identifier hs-var hs-var hs-var hs-var">bifoldMap</span></a></span></span><span> </span><span id="local-6989586621679085068"><span class="annot"><span class="annottext">a -&gt; m
</span><a href="#local-6989586621679085068"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="annot"><span class="annottext">b -&gt; m
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085067"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085067"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; m
</span><a href="#local-6989586621679085068"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085067"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-141"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Bifoldable.html#bifoldMap"><span class="hs-pragma hs-type">bifoldMap</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-142"></span><span>
</span><span id="line-143"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/Data.Bitraversable.html#Bitraversable"><span class="hs-identifier hs-type">Bitraversable</span></a></span><span> </span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-144"></span><span>    </span><span id="local-6989586621679085055"><span class="annot"><span class="annottext">bitraverse :: forall (f :: * -&gt; *) a c b d.
Applicative f =&gt;
(a -&gt; f c) -&gt; (b -&gt; f d) -&gt; Constant a b -&gt; f (Constant c d)
</span><a href="../../base/src/Data.Bitraversable.html#bitraverse"><span class="hs-identifier hs-var hs-var hs-var hs-var">bitraverse</span></a></span></span><span> </span><span id="local-6989586621679085053"><span class="annot"><span class="annottext">a -&gt; f c
</span><a href="#local-6989586621679085053"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="annot"><span class="annottext">b -&gt; f d
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085052"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085052"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">c -&gt; Constant c d
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">(c -&gt; Constant c d) -&gt; f c -&gt; f (Constant c d)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; f c
</span><a href="#local-6989586621679085053"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085052"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-145"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Bitraversable.html#bitraverse"><span class="hs-pragma hs-type">bitraverse</span></a></span><span> </span><span class="hs-pragma">#-}</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">
#if MIN_VERSION_base(4,12,0)
</span><span id="local-6989586621679085440"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679085048"><span class="annot"><a href="../../base/src/Data.Functor.Contravariant.html#Contravariant"><span class="hs-identifier hs-type">Contravariant</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679085440"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-150"></span><span>    </span><span id="local-6989586621679085046"><span class="annot"><span class="annottext">contramap :: forall a' a. (a' -&gt; a) -&gt; Constant a a -&gt; Constant a a'
</span><a href="../../base/src/Data.Functor.Contravariant.html#contramap"><span class="hs-identifier hs-var hs-var hs-var hs-var">contramap</span></a></span></span><span> </span><span class="annot"><span class="annottext">a' -&gt; a
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-type">Constant</span></a></span><span> </span><span id="local-6989586621679085044"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085044"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Constant a a'
forall {k} a (b :: k). a -&gt; Constant a b
</span><a href="Data.Functor.Constant.html#Constant"><span class="hs-identifier hs-var">Constant</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679085044"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-151"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Contravariant.html#contramap"><span class="hs-pragma hs-type">contramap</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span class="hs-cpp">
#endif
</span></pre></body></html>